home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / game / shoot / ADoomPPC_src.lha / ADoomPPC_src / g_game.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-18  |  41.4 KB  |  1,700 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:  none
  20. //
  21. //-----------------------------------------------------------------------------
  22.  
  23.  
  24. static const char
  25. rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
  26.  
  27. #include <string.h>
  28. #include <stdlib.h>
  29.  
  30. #include "doomdef.h" 
  31. #include "doomstat.h"
  32.  
  33. #include "z_zone.h"
  34. #include "f_finale.h"
  35. #include "m_argv.h"
  36. #include "m_misc.h"
  37. #include "m_menu.h"
  38. #include "m_random.h"
  39. #include "i_system.h"
  40.  
  41. #include "p_setup.h"
  42. #include "p_saveg.h"
  43. #include "p_tick.h"
  44.  
  45. #include "d_main.h"
  46.  
  47. #include "wi_stuff.h"
  48. #include "hu_stuff.h"
  49. #include "st_stuff.h"
  50. #include "am_map.h"
  51.  
  52. // Needs access to LFB.
  53. #include "v_video.h"
  54.  
  55. #include "w_wad.h"
  56.  
  57. #include "p_local.h" 
  58.  
  59. #include "s_sound.h"
  60.  
  61. // Data.
  62. #include "dstrings.h"
  63. #include "sounds.h"
  64.  
  65. // SKY handling - still the wrong place.
  66. #include "r_data.h"
  67. #include "r_sky.h"
  68.  
  69.  
  70.  
  71. #include "g_game.h"
  72.  
  73.  
  74. //#define SAVEGAMESIZE  0x2c000
  75. #define SAVEGAMESIZE    0x50000
  76. #define SAVESTRINGSIZE  24
  77.  
  78.  
  79.  
  80. boolean G_CheckDemoStatus (void); 
  81. void    G_ReadDemoTiccmd (ticcmd_t* cmd); 
  82. void    G_WriteDemoTiccmd (ticcmd_t* cmd); 
  83. void    G_PlayerReborn (int player); 
  84. void    G_InitNew (skill_t skill, int episode, int map); 
  85.  
  86. void    G_DoReborn (int playernum); 
  87.  
  88. void    G_DoLoadLevel (void); 
  89. void    G_DoNewGame (void); 
  90. void    G_DoLoadGame (void); 
  91. void    G_DoPlayDemo (void); 
  92. void    G_DoCompleted (void); 
  93. void    G_DoVictory (void); 
  94. void    G_DoWorldDone (void); 
  95. void    G_DoSaveGame (void); 
  96.  
  97.  
  98. gameaction_t    gameaction; 
  99. gamestate_t     gamestate; 
  100. skill_t         gameskill; 
  101. boolean         respawnmonsters;
  102. int             gameepisode; 
  103. int             gamemap; 
  104.  
  105. boolean         paused; 
  106. boolean         sendpause;              // send a pause event next tic 
  107. boolean         sendsave;               // send a save event next tic 
  108. boolean         usergame;               // ok to save / end game 
  109.  
  110. boolean         timingdemo;             // if true, exit with report on completion 
  111. boolean         nodrawers;              // for comparative timing purposes 
  112. boolean         noblit;                 // for comparative timing purposes 
  113. int             starttime;              // for comparative timing purposes       
  114.  
  115. boolean         viewactive; 
  116.  
  117. boolean         deathmatch;             // only if started as net death 
  118. boolean         netgame;                // only true if packets are broadcast 
  119. boolean         playeringame[MAXPLAYERS]; 
  120. player_t        players[MAXPLAYERS]; 
  121.  
  122. int             consoleplayer;          // player taking events and displaying 
  123. int             displayplayer;          // view being displayed 
  124. int             gametic; 
  125. int             levelstarttic;          // gametic at level start 
  126. int             totalkills, totalitems, totalsecret;    // for intermission 
  127.  
  128. char            demoname[32]; 
  129. boolean         demorecording; 
  130. boolean         demoplayback; 
  131. boolean         netdemo; 
  132. byte*           demobuffer;
  133. byte*           demo_p;
  134. byte*           demoend; 
  135. boolean         singledemo;             // quit after playing a demo from cmdline 
  136.  
  137. boolean         precache = true;        // if true, load all graphics at start 
  138.  
  139. wbstartstruct_t wminfo;                 // parms for world map / intermission 
  140.  
  141. short           consistancy[MAXPLAYERS][BACKUPTICS]; 
  142.  
  143. byte*           savebuffer;
  144.  
  145. // Dehacked
  146. int initial_health=100;
  147. int initial_bullets=50;
  148.  
  149. // 
  150. // controls (have defaults) 
  151. // 
  152. int             key_right;
  153. int             key_left;
  154.  
  155. int             key_up;
  156. int             key_down; 
  157. int             key_strafeleft;
  158. int             key_straferight; 
  159. int             key_fire;
  160. int             key_use;
  161. int             key_strafe;
  162. int             key_speed; 
  163.  
  164. int             mousebfire; 
  165. int             mousebstrafe; 
  166. int             mousebforward; 
  167.  
  168. int             joybfire; 
  169. int             joybstrafe; 
  170. int             joybuse; 
  171. int             joybspeed; 
  172.  
  173.  
  174.  
  175. #define MAXPLMOVE               (forwardmove[1]) 
  176.  
  177. #define TURBOTHRESHOLD  0x32
  178.  
  179. fixed_t         forwardmove[2] = {0x19, 0x32}; 
  180. fixed_t         sidemove[2] = {0x18, 0x28}; 
  181. fixed_t         angleturn[3] = {640, 1280, 320};        // + slow turn 
  182.  
  183. #define SLOWTURNTICS    6 
  184.  
  185. #define NUMKEYS         256 
  186.  
  187. boolean         gamekeydown[NUMKEYS]; 
  188. int             turnheld;                               // for accelerative turning 
  189.  
  190. boolean         mousearray[4]; 
  191. boolean*        mousebuttons = &mousearray[1];          // allow [-1]
  192.  
  193. // mouse values are used once 
  194. int             mousex;
  195. int             mousey;         
  196.  
  197. int             dclicktime;
  198. int             dclickstate;
  199. int             dclicks; 
  200. int             dclicktime2;
  201. int             dclickstate2;
  202. int             dclicks2;
  203.  
  204. // joystick values are repeated 
  205. int             joyxmove;
  206. int             joyymove;
  207. boolean         joyarray[5]; 
  208. boolean*        joybuttons = &joyarray[1];              // allow [-1] 
  209.  
  210. int             savegameslot; 
  211. char            savedescription[32]; 
  212.  
  213.  
  214. #define BODYQUESIZE     32
  215.  
  216. mobj_t*         bodyque[BODYQUESIZE]; 
  217. int             bodyqueslot; 
  218.  
  219. void*           statcopy;                               // for statistics driver
  220.  
  221.  
  222.  
  223. int G_CmdChecksum (ticcmd_t* cmd) 
  224. { 
  225.     int         i;
  226.     int         sum = 0; 
  227.          
  228.     for (i=0 ; i< sizeof(*cmd)/4 - 1 ; i++) 
  229.         sum += ((int *)cmd)[i]; 
  230.                  
  231.     return sum; 
  232. } 
  233.  
  234.  
  235. //
  236. // G_BuildTiccmd
  237. // Builds a ticcmd from all of the available inputs
  238. // or reads it from the demo buffer. 
  239. // If recording a demo, write it out 
  240. // 
  241. void G_BuildTiccmd (ticcmd_t* cmd) 
  242. { 
  243.     int         i; 
  244.     boolean     strafe;
  245.     boolean     bstrafe; 
  246.     int         speed;
  247.     int         tspeed; 
  248.     int         forward;
  249.     int         side;
  250.     
  251.     ticcmd_t*   base;
  252.  
  253.     base = I_BaseTiccmd ();             // empty, or external driver
  254.     memcpy (cmd,base,sizeof(*cmd)); 
  255.         
  256.     cmd->consistancy = 
  257.         consistancy[consoleplayer][maketic%BACKUPTICS]; 
  258.  
  259.  
  260.     strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe] 
  261.         || joybuttons[joybstrafe]; 
  262.     speed = gamekeydown[key_speed] || joybuttons[joybspeed];
  263.  
  264.     forward = side = 0;
  265.     
  266.     // use two stage accelerative turning
  267.     // on the keyboard and joystick
  268.     if (joyxmove < 0
  269.         || joyxmove > 0  
  270.         || gamekeydown[key_right]
  271.         || gamekeydown[key_left]) 
  272.         turnheld += ticdup; 
  273.     else 
  274.         turnheld = 0; 
  275.  
  276.     if (turnheld < SLOWTURNTICS) 
  277.         tspeed = 2;             // slow turn 
  278.     else 
  279.         tspeed = speed;
  280.     
  281.     // let movement keys cancel each other out
  282.     if (strafe) 
  283.     { 
  284.         if (gamekeydown[key_right]) 
  285.         {
  286.             // fprintf(stderr, "strafe right\n");
  287.             side += sidemove[speed]; 
  288.         }
  289.         if (gamekeydown[key_left]) 
  290.         {
  291.             //  fprintf(stderr, "strafe left\n");
  292.             side -= sidemove[speed]; 
  293.         }
  294.         if (joyxmove > 0) 
  295.             side += sidemove[speed]; 
  296.         if (joyxmove < 0) 
  297.             side -= sidemove[speed]; 
  298.  
  299.     } 
  300.     else 
  301.     { 
  302.         if (gamekeydown[key_right]) 
  303.             cmd->angleturn -= angleturn[tspeed]; 
  304.         if (gamekeydown[key_left]) 
  305.             cmd->angleturn += angleturn[tspeed]; 
  306.         if (joyxmove > 0) 
  307.             cmd->angleturn -= angleturn[tspeed]; 
  308.         if (joyxmove < 0) 
  309.             cmd->angleturn += angleturn[tspeed]; 
  310.     } 
  311.  
  312.     if (gamekeydown[key_up]) 
  313.     {
  314. //        fprintf(stderr, "up\n");
  315.         forward += forwardmove[speed];
  316. //                fprintf(stderr, "speed: %ld\n", forward); 
  317.     }
  318.     if (gamekeydown[key_down]) 
  319.     {
  320. //         fprintf(stderr, "down\n");
  321.         forward -= forwardmove[speed];
  322. //                fprintf(stderr, "speed: %ld\n", forward);
  323.     }
  324.     if (joyymove < 0) 
  325.         forward += forwardmove[speed]; 
  326.     if (joyymove > 0) 
  327.         forward -= forwardmove[speed]; 
  328.     if (gamekeydown[key_straferight]) 
  329.         side += sidemove[speed]; 
  330.     if (gamekeydown[key_strafeleft]) 
  331.         side -= sidemove[speed];
  332.     
  333.     // buttons
  334.     cmd->chatchar = HU_dequeueChatChar(); 
  335.  
  336.     if (gamekeydown[key_fire] || mousebuttons[mousebfire] 
  337.         || joybuttons[joybfire]) 
  338.         cmd->buttons |= BT_ATTACK; 
  339.  
  340.     if (gamekeydown[key_use] || joybuttons[joybuse] ) 
  341.     { 
  342.         cmd->buttons |= BT_USE;
  343.         // clear double clicks if hit use button 
  344.         dclicks = 0;                   
  345.     } 
  346.  
  347.     // chainsaw overrides 
  348.     for (i=0 ; i<NUMWEAPONS-1 ; i++)        
  349.         if (gamekeydown['1'+i]) 
  350.         { 
  351.             cmd->buttons |= BT_CHANGE; 
  352.             cmd->buttons |= i<<BT_WEAPONSHIFT; 
  353.             break; 
  354.         }
  355.     
  356.     // mouse
  357.     if (mousebuttons[mousebforward]) 
  358.         forward += forwardmove[speed];
  359.     
  360.     // forward double click
  361.     if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 ) 
  362.     { 
  363.         dclickstate = mousebuttons[mousebforward]; 
  364.         if (dclickstate) 
  365.             dclicks++; 
  366.         if (dclicks == 2) 
  367.         { 
  368.             cmd->buttons |= BT_USE; 
  369.             dclicks = 0; 
  370.         } 
  371.         else 
  372.             dclicktime = 0; 
  373.     } 
  374.     else 
  375.     { 
  376.         dclicktime += ticdup; 
  377.         if (dclicktime > 20) 
  378.         { 
  379.             dclicks = 0; 
  380.             dclickstate = 0; 
  381.         } 
  382.     }
  383.     
  384.     // strafe double click
  385.     bstrafe =
  386.         mousebuttons[mousebstrafe] 
  387.         || joybuttons[joybstrafe]; 
  388.     if (bstrafe != dclickstate2 && dclicktime2 > 1 ) 
  389.     { 
  390.         dclickstate2 = bstrafe; 
  391.         if (dclickstate2) 
  392.             dclicks2++; 
  393.         if (dclicks2 == 2) 
  394.         { 
  395.             cmd->buttons |= BT_USE; 
  396.             dclicks2 = 0; 
  397.         } 
  398.         else 
  399.             dclicktime2 = 0; 
  400.     } 
  401.     else 
  402.     { 
  403.         dclicktime2 += ticdup; 
  404.         if (dclicktime2 > 20) 
  405.         { 
  406.             dclicks2 = 0; 
  407.             dclickstate2 = 0; 
  408.         } 
  409.     } 
  410.  
  411.     forward += mousey; 
  412.     if (strafe) 
  413.         side += mousex*2; 
  414.     else 
  415.         cmd->angleturn -= mousex*0x8; 
  416.  
  417.     mousex = mousey = 0; 
  418.          
  419.     if (forward > MAXPLMOVE) 
  420.         forward = MAXPLMOVE; 
  421.     else if (forward < -MAXPLMOVE) 
  422.         forward = -MAXPLMOVE; 
  423.     if (side > MAXPLMOVE) 
  424.         side = MAXPLMOVE; 
  425.     else if (side < -MAXPLMOVE) 
  426.         side = -MAXPLMOVE; 
  427.  
  428. //        fprintf(stderr, "forward: %ld\n", forward);
  429.     cmd->forwardmove += forward;
  430. //        fprintf(stderr, "cmd->forwardmove: %ld\n", cmd->forwardmove);
  431.     cmd->sidemove += side;
  432.     
  433.     // special buttons
  434.     if (sendpause) 
  435.     { 
  436.         sendpause = false; 
  437.         cmd->buttons = BT_SPECIAL | BTS_PAUSE; 
  438.     } 
  439.  
  440.     if (sendsave) 
  441.     { 
  442.         sendsave = false; 
  443.         cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT); 
  444.     } 
  445. } 
  446.  
  447.  
  448. //
  449. // G_DoLoadLevel 
  450. //
  451. extern  gamestate_t     wipegamestate; 
  452.  
  453. void G_DoLoadLevel (void) 
  454. { 
  455.     int             i; 
  456.  
  457.     // Set the sky map.
  458.     // First thing, we have a dummy sky texture name,
  459.     //  a flat. The data is in the WAD only because
  460.     //  we look for an actual index, instead of simply
  461.     //  setting one.
  462.     skyflatnum = R_FlatNumForName ( SKYFLATNAME );
  463.  
  464.     // DOOM determines the sky texture to be used
  465.     // depending on the current episode, and the game version.
  466.     if ( (gamemode == commercial)
  467.          || ( gamemode == pack_tnt )
  468.          || ( gamemode == pack_plut ) )
  469.     {
  470.         skytexture = R_TextureNumForName ("SKY3");
  471.         if (gamemap < 12)
  472.             skytexture = R_TextureNumForName ("SKY1");
  473.         else
  474.             if (gamemap < 21)
  475.                 skytexture = R_TextureNumForName ("SKY2");
  476.     }
  477.  
  478.     levelstarttic = gametic;        // for time calculation
  479.     
  480.     if (wipegamestate == GS_LEVEL) 
  481.         wipegamestate = -1;             // force a wipe 
  482.  
  483.     gamestate = GS_LEVEL; 
  484.  
  485.     for (i=0 ; i<MAXPLAYERS ; i++) 
  486.     { 
  487.         if (playeringame[i] && players[i].playerstate == PST_DEAD) 
  488.             players[i].playerstate = PST_REBORN; 
  489.         memset (players[i].frags,0,sizeof(players[i].frags)); 
  490.     } 
  491.                  
  492.     P_SetupLevel (gameepisode, gamemap, 0, gameskill);    
  493.     displayplayer = consoleplayer;              // view the guy you are playing    
  494.     starttime = I_GetTime (); 
  495.     gameaction = ga_nothing; 
  496.     Z_CheckHeap ();
  497.     
  498.     // clear cmd building stuff
  499.     memset (gamekeydown, 0, sizeof(gamekeydown)); 
  500.     joyxmove = joyymove = 0; 
  501.     mousex = mousey = 0; 
  502.     sendpause = sendsave = paused = false; 
  503.     memset (mousebuttons, 0, sizeof(mousebuttons)); 
  504.     memset (joybuttons, 0, sizeof(joybuttons)); 
  505. } 
  506.  
  507.  
  508. //
  509. // G_Responder  
  510. // Get info needed to make ticcmd_ts for the players.
  511. // 
  512. boolean G_Responder (event_t* ev) 
  513. { 
  514.     // allow spy mode changes even during the demo
  515.     if (gamestate == GS_LEVEL && ev->type == ev_keydown 
  516.         && ev->data1 == KEY_F12 && (singledemo || !deathmatch) )
  517.     {
  518.         // spy mode 
  519.         do 
  520.         { 
  521.             displayplayer++; 
  522.             if (displayplayer == MAXPLAYERS) 
  523.                 displayplayer = 0; 
  524.         } while (!playeringame[displayplayer] && displayplayer != consoleplayer); 
  525.         return true; 
  526.     }
  527.     
  528.     // any other key pops up menu if in demos
  529.     if (gameaction == ga_nothing && !singledemo && 
  530.         (demoplayback || gamestate == GS_DEMOSCREEN) 
  531.         ) 
  532.     { 
  533.         if (ev->type == ev_keydown ||  
  534.             (ev->type == ev_mouse && ev->data1) || 
  535.             (ev->type == ev_joystick && ev->data1) ) 
  536.         { 
  537.             M_StartControlPanel (); 
  538.             return true; 
  539.         } 
  540.         return false; 
  541.     } 
  542.  
  543.     if (gamestate == GS_LEVEL) 
  544.     { 
  545. #if 0 
  546.         if (devparm && ev->type == ev_keydown && ev->data1 == ';') 
  547.         { 
  548.             G_DeathMatchSpawnPlayer (0); 
  549.             return true; 
  550.         } 
  551. #endif 
  552.         if (HU_Responder (ev)) 
  553.             return true;        // chat ate the event 
  554.         if (ST_Responder (ev)) 
  555.             return true;        // status window ate it 
  556.         if (AM_Responder (ev)) 
  557.             return true;        // automap ate it 
  558.     } 
  559.          
  560.     if (gamestate == GS_FINALE) 
  561.     { 
  562.         if (F_Responder (ev)) 
  563.             return true;        // finale ate the event 
  564.     } 
  565.          
  566.     switch (ev->type) 
  567.     { 
  568.       case ev_keydown: 
  569.         if (ev->data1 == KEY_PAUSE) 
  570.         { 
  571.             sendpause = true; 
  572.             return true; 
  573.         } 
  574.         if (ev->data1 <NUMKEYS) 
  575.             gamekeydown[ev->data1] = true; 
  576.         return true;    // eat key down events 
  577.  
  578.       case ev_keyup: 
  579.         if (ev->data1 <NUMKEYS) 
  580.             gamekeydown[ev->data1] = false; 
  581.         return false;   // always let key up events filter down 
  582.                  
  583.       case ev_mouse: 
  584.         mousebuttons[0] = ev->data1 & 1; 
  585.         mousebuttons[1] = ev->data1 & 2; 
  586.         mousebuttons[2] = ev->data1 & 4; 
  587.         mousex = ev->data2*(mouseSensitivity+5)/10; 
  588.         mousey = ev->data3*(mouseSensitivity+5)/10; 
  589.         return true;    // eat events 
  590.  
  591.       case ev_joystick: 
  592.         joybuttons[0] = ev->data1 & 1; 
  593.         joybuttons[1] = ev->data1 & 2; 
  594.         joybuttons[2] = ev->data1 & 4; 
  595.         joybuttons[3] = ev->data1 & 8; 
  596.         joyxmove = ev->data2; 
  597.         joyymove = ev->data3; 
  598.         return true;    // eat events 
  599.  
  600.       default: 
  601.         break; 
  602.     } 
  603.  
  604.     return false; 
  605. } 
  606.  
  607.  
  608.  
  609. //
  610. // G_Ticker
  611. // Make ticcmd_ts for the players.
  612. //
  613. void G_Ticker (void) 
  614. { 
  615.     int         i;
  616.     int         buf; 
  617.     ticcmd_t*   cmd;
  618.     
  619.     // do player reborns if needed
  620.     for (i=0 ; i<MAXPLAYERS ; i++) 
  621.         if (playeringame[i] && players[i].playerstate == PST_REBORN) 
  622.             G_DoReborn (i);
  623.     
  624.     // do things to change the game state
  625.     while (gameaction != ga_nothing) 
  626.     { 
  627.         switch (gameaction) 
  628.         { 
  629.           case ga_loadlevel: 
  630.             G_DoLoadLevel (); 
  631.             break; 
  632.           case ga_newgame: 
  633.             G_DoNewGame (); 
  634.             break; 
  635.           case ga_loadgame: 
  636.             G_DoLoadGame (); 
  637.             break; 
  638.           case ga_savegame: 
  639.             G_DoSaveGame (); 
  640.             break; 
  641.           case ga_playdemo: 
  642.             G_DoPlayDemo (); 
  643.             break; 
  644.           case ga_completed: 
  645.             G_DoCompleted (); 
  646.             break; 
  647.           case ga_victory: 
  648.             F_StartFinale (); 
  649.             break; 
  650.           case ga_worlddone: 
  651.             G_DoWorldDone (); 
  652.             break; 
  653.           case ga_screenshot: 
  654.             M_ScreenShot (); 
  655.             gameaction = ga_nothing; 
  656.             break; 
  657.           case ga_nothing: 
  658.             break; 
  659.         } 
  660.     }
  661.     
  662.     // get commands, check consistancy,
  663.     // and build new consistancy check
  664.     buf = (gametic/ticdup)%BACKUPTICS; 
  665.  
  666.     for (i=0 ; i<MAXPLAYERS ; i++)
  667.     {
  668.         if (playeringame[i]) 
  669.         { 
  670.             cmd = &players[i].cmd; 
  671.  
  672.             memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t)); 
  673.  
  674.             if (demoplayback) 
  675.                 G_ReadDemoTiccmd (cmd); 
  676.             if (demorecording) 
  677.                 G_WriteDemoTiccmd (cmd);
  678.             
  679.             // check for turbo cheats
  680.             if (cmd->forwardmove > TURBOTHRESHOLD 
  681.                 && !(gametic&31) && ((gametic>>5)&3) == i )
  682.             {
  683.                 static char turbomessage[80];
  684.                 extern char *player_names[4];
  685.                 sprintf (turbomessage, "%s is turbo!",player_names[i]);
  686.                 players[consoleplayer].message = turbomessage;
  687.             }
  688.                         
  689.             if (netgame && !netdemo && !(gametic%ticdup) ) 
  690.             { 
  691.                 if (gametic > BACKUPTICS 
  692.                     && consistancy[i][buf] != cmd->consistancy) 
  693.                 { 
  694.                     I_Error ("consistency failure (%i should be %i)",
  695.                              cmd->consistancy, consistancy[i][buf]); 
  696.                 } 
  697.                 if (players[i].mo) 
  698.                     consistancy[i][buf] = players[i].mo->x; 
  699.                 else 
  700.                     consistancy[i][buf] = rndindex; 
  701.             } 
  702.         }
  703.     }
  704.     
  705.     // check for special buttons
  706.     for (i=0 ; i<MAXPLAYERS ; i++)
  707.     {
  708.         if (playeringame[i]) 
  709.         { 
  710.             if (players[i].cmd.buttons & BT_SPECIAL) 
  711.             { 
  712.                 switch (players[i].cmd.buttons & BT_SPECIALMASK) 
  713.                 { 
  714.                   case BTS_PAUSE: 
  715.                     paused ^= 1; 
  716.                     if (paused) 
  717.                         S_PauseSound (); 
  718.                     else 
  719.                         S_ResumeSound (); 
  720.                     break; 
  721.                                          
  722.                   case BTS_SAVEGAME: 
  723.                     if (!savedescription[0]) 
  724.                         strcpy (savedescription, "NET GAME"); 
  725.                     savegameslot =  
  726.                         (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT; 
  727.                     gameaction = ga_savegame; 
  728.                     break; 
  729.                 } 
  730.             } 
  731.         }
  732.     }
  733.     
  734.     // do main actions
  735.     switch (gamestate) 
  736.     { 
  737.       case GS_LEVEL: 
  738.         P_Ticker (); 
  739.         ST_Ticker (); 
  740.         AM_Ticker (); 
  741.         HU_Ticker ();            
  742.         break; 
  743.          
  744.       case GS_INTERMISSION: 
  745.         WI_Ticker (); 
  746.         break; 
  747.                          
  748.       case GS_FINALE: 
  749.         F_Ticker (); 
  750.         break; 
  751.  
  752.       case GS_DEMOSCREEN: 
  753.         D_PageTicker (); 
  754.         break; 
  755.     }        
  756. } 
  757.  
  758.  
  759. //
  760. // PLAYER STRUCTURE FUNCTIONS
  761. // also see P_SpawnPlayer in P_Things
  762. //
  763.  
  764. //
  765. // G_InitPlayer 
  766. // Called at the start.
  767. // Called by the game initialization functions.
  768. //
  769. void G_InitPlayer (int player) 
  770. { 
  771.     player_t*   p; 
  772.  
  773.     // set up the saved info         
  774.     p = &players[player]; 
  775.          
  776.     // clear everything else to defaults 
  777.     G_PlayerReborn (player); 
  778.          
  779. } 
  780.  
  781.  
  782.  
  783. //
  784. // G_PlayerFinishLevel
  785. // Can when a player completes a level.
  786. //
  787. void G_PlayerFinishLevel (int player) 
  788. { 
  789.     player_t*   p; 
  790.          
  791.     p = &players[player]; 
  792.          
  793.     memset (p->powers, 0, sizeof (p->powers)); 
  794.     memset (p->cards, 0, sizeof (p->cards)); 
  795.     p->mo->flags &= ~MF_SHADOW;         // cancel invisibility 
  796.     p->extralight = 0;                  // cancel gun flashes 
  797.     p->fixedcolormap = 0;               // cancel ir gogles 
  798.     p->damagecount = 0;                 // no palette changes 
  799.     p->bonuscount = 0; 
  800. } 
  801.  
  802.  
  803. //
  804. // G_PlayerReborn
  805. // Called after a player dies 
  806. // almost everything is cleared and initialized 
  807. //
  808. void G_PlayerReborn (int player) 
  809. { 
  810.     player_t*   p; 
  811.     int         i; 
  812.     int         frags[MAXPLAYERS]; 
  813.     int         killcount;
  814.     int         itemcount;
  815.     int         secretcount; 
  816.          
  817.     memcpy (frags,players[player].frags,sizeof(frags)); 
  818.     killcount = players[player].killcount; 
  819.     itemcount = players[player].itemcount; 
  820.     secretcount = players[player].secretcount; 
  821.          
  822.     p = &players[player]; 
  823.     memset (p, 0, sizeof(*p)); 
  824.  
  825.     memcpy (players[player].frags, frags, sizeof(players[player].frags)); 
  826.     players[player].killcount = killcount; 
  827.     players[player].itemcount = itemcount; 
  828.     players[player].secretcount = secretcount; 
  829.  
  830.     p->usedown = p->attackdown = true;  // don't do anything immediately 
  831.     p->playerstate = PST_LIVE;       
  832.     p->health = initial_health; // Dehacked
  833.     p->readyweapon = p->pendingweapon = wp_pistol; 
  834.     p->weaponowned[wp_fist] = true; 
  835.     p->weaponowned[wp_pistol] = true; 
  836.     p->ammo[am_clip] = initial_bullets; // Dehacked
  837.          
  838.     for (i=0 ; i<NUMAMMO ; i++) 
  839.         p->maxammo[i] = maxammo[i]; 
  840.                  
  841. }
  842.  
  843. //
  844. // G_CheckSpot  
  845. // Returns false if the player cannot be respawned
  846. // at the given mapthing_t spot  
  847. // because something is occupying it 
  848. //
  849. void P_SpawnPlayer (mapthing_t* mthing); 
  850.  
  851. boolean
  852. G_CheckSpot
  853. ( int           playernum,
  854.   mapthing_t*   mthing ) 
  855. { 
  856.     fixed_t             x;
  857.     fixed_t             y; 
  858.     subsector_t*        ss; 
  859.     unsigned            an; 
  860.     mobj_t*             mo; 
  861.     int                 i;
  862.         
  863.     if (!players[playernum].mo)
  864.     {
  865.         // first spawn of level, before corpses
  866.         for (i=0 ; i<playernum ; i++)
  867.             if (players[i].mo->x == mthing->x << FRACBITS
  868.                 && players[i].mo->y == mthing->y << FRACBITS)
  869.                 return false;   
  870.         return true;
  871.     }
  872.                 
  873.     x = mthing->x << FRACBITS; 
  874.     y = mthing->y << FRACBITS; 
  875.          
  876.     if (!P_CheckPosition (players[playernum].mo, x, y) ) 
  877.         return false; 
  878.  
  879.     // flush an old corpse if needed 
  880.     if (bodyqueslot >= BODYQUESIZE) 
  881.         P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]); 
  882.     bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo; 
  883.     bodyqueslot++; 
  884.         
  885.     // spawn a teleport fog 
  886.     ss = R_PointInSubsector (x,y); 
  887.     an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT; 
  888.  
  889.     mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an] 
  890.                       , ss->sector->floorheight 
  891.                       , MT_TFOG); 
  892.          
  893.     if (players[consoleplayer].viewz != 1) 
  894.         S_StartSound (mo, sfx_telept);  // don't start sound on first frame 
  895.  
  896.     return true; 
  897. } 
  898.  
  899.  
  900. //
  901. // G_DeathMatchSpawnPlayer 
  902. // Spawns a player at one of the random death match spots 
  903. // called at level load and each death 
  904. //
  905. void G_DeathMatchSpawnPlayer (int playernum) 
  906. { 
  907.     int             i,j; 
  908.     int                         selections; 
  909.          
  910.     selections = deathmatch_p - deathmatchstarts; 
  911.     if (selections < 4) 
  912.         I_Error ("Only %i deathmatch spots, 4 required", selections); 
  913.  
  914.     for (j=0 ; j<20 ; j++) 
  915.     { 
  916.         i = P_Random() % selections; 
  917.         if (G_CheckSpot (playernum, &deathmatchstarts[i]) ) 
  918.         { 
  919.             deathmatchstarts[i].type = playernum+1; 
  920.             P_SpawnPlayer (&deathmatchstarts[i]); 
  921.             return; 
  922.         } 
  923.     } 
  924.  
  925.     // no good spot, so the player will probably get stuck 
  926.     P_SpawnPlayer (&playerstarts[playernum]); 
  927. } 
  928.  
  929. //
  930. // G_DoReborn 
  931. // 
  932. void G_DoReborn (int playernum) 
  933. { 
  934.     int                             i; 
  935.          
  936.     if (!netgame)
  937.     {
  938.         // reload the level from scratch
  939.         gameaction = ga_loadlevel;  
  940.     }
  941.     else 
  942.     {
  943.         // respawn at the start
  944.  
  945.         // first dissasociate the corpse 
  946.         players[playernum].mo->player = NULL;   
  947.                  
  948.         // spawn at random spot if in death match 
  949.         if (deathmatch) 
  950.         { 
  951.             G_DeathMatchSpawnPlayer (playernum); 
  952.             return; 
  953.         } 
  954.                  
  955.         if (G_CheckSpot (playernum, &playerstarts[playernum]) ) 
  956.         { 
  957.             P_SpawnPlayer (&playerstarts[playernum]); 
  958.             return; 
  959.         }
  960.         
  961.         // try to spawn at one of the other players spots 
  962.         for (i=0 ; i<MAXPLAYERS ; i++)
  963.         {
  964.             if (G_CheckSpot (playernum, &playerstarts[i]) ) 
  965.             { 
  966.                 playerstarts[i].type = playernum+1;     // fake as other player 
  967.                 P_SpawnPlayer (&playerstarts[i]); 
  968.                 playerstarts[i].type = i+1;             // restore 
  969.                 return; 
  970.             }       
  971.             // he's going to be inside something.  Too bad.
  972.         }
  973.         P_SpawnPlayer (&playerstarts[playernum]); 
  974.     } 
  975. } 
  976.  
  977.  
  978. void G_ScreenShot (void) 
  979. { 
  980.     gameaction = ga_screenshot; 
  981. } 
  982.  
  983.  
  984.  
  985. // DOOM Par Times
  986. int pars[4][10] = 
  987. { 
  988.     {0}, 
  989.     {0,30,75,120,90,165,180,180,30,165}, 
  990.     {0,90,90,90,120,90,360,240,30,170}, 
  991.     {0,90,45,90,150,90,90,165,30,135} 
  992. }; 
  993.  
  994. // DOOM II Par Times
  995. int cpars[32] =
  996. {
  997.     30,90,120,120,90,150,120,120,270,90,        //  1-10
  998.     210,150,150,150,210,150,420,150,210,150,    // 11-20
  999.     240,150,180,150,150,300,330,420,300,180,    // 21-30
  1000.     120,30                                      // 31-32
  1001. };
  1002.  
  1003.  
  1004. //
  1005. // G_DoCompleted 
  1006. //
  1007. boolean         secretexit; 
  1008. extern char*    pagename; 
  1009.  
  1010. void G_ExitLevel (void) 
  1011. { 
  1012.     secretexit = false; 
  1013.     gameaction = ga_completed; 
  1014. } 
  1015.  
  1016. // Here's for the german edition.
  1017. void G_SecretExitLevel (void) 
  1018. { 
  1019.     // IF NO WOLF3D LEVELS, NO SECRET EXIT!
  1020.     if ( (gamemode == commercial)
  1021.       && (W_CheckNumForName("map31")<0))
  1022.         secretexit = false;
  1023.     else
  1024.         secretexit = true; 
  1025.     gameaction = ga_completed; 
  1026. } 
  1027.  
  1028. void G_DoCompleted (void) 
  1029. { 
  1030.     int             i; 
  1031.          
  1032.     gameaction = ga_nothing; 
  1033.  
  1034.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1035.         if (playeringame[i]) 
  1036.             G_PlayerFinishLevel (i);        // take away cards and stuff 
  1037.          
  1038.     if (automapactive) 
  1039.         AM_Stop (); 
  1040.         
  1041.     if ( gamemode != commercial)
  1042.         switch(gamemap)
  1043.         {
  1044.           case 8:
  1045.             gameaction = ga_victory;
  1046.             return;
  1047.           case 9: 
  1048.             for (i=0 ; i<MAXPLAYERS ; i++) 
  1049.                 players[i].didsecret = true; 
  1050.             break;
  1051.         }
  1052.                 
  1053. //#if 0  Hmmm - why?
  1054.     if ( (gamemap == 8)
  1055.          && (gamemode != commercial) ) 
  1056.     {
  1057.         // victory 
  1058.         gameaction = ga_victory; 
  1059.         return; 
  1060.     } 
  1061.          
  1062.     if ( (gamemap == 9)
  1063.          && (gamemode != commercial) ) 
  1064.     {
  1065.         // exit secret level 
  1066.         for (i=0 ; i<MAXPLAYERS ; i++) 
  1067.             players[i].didsecret = true; 
  1068.     } 
  1069. //#endif
  1070.     
  1071.          
  1072.     wminfo.didsecret = players[consoleplayer].didsecret; 
  1073.     wminfo.epsd = gameepisode -1; 
  1074.     wminfo.last = gamemap -1;
  1075.     
  1076.     // wminfo.next is 0 biased, unlike gamemap
  1077.     if ( gamemode == commercial)
  1078.     {
  1079.         if (secretexit)
  1080.             switch(gamemap)
  1081.             {
  1082.               case 15: wminfo.next = 30; break;
  1083.               case 31: wminfo.next = 31; break;
  1084.             }
  1085.         else
  1086.             switch(gamemap)
  1087.             {
  1088.               case 31:
  1089.               case 32: wminfo.next = 15; break;
  1090.               default: wminfo.next = gamemap;
  1091.             }
  1092.     }
  1093.     else
  1094.     {
  1095.         if (secretexit) 
  1096.             wminfo.next = 8;    // go to secret level 
  1097.         else if (gamemap == 9) 
  1098.         {
  1099.             // returning from secret level 
  1100.             switch (gameepisode) 
  1101.             { 
  1102.               case 1: 
  1103.                 wminfo.next = 3; 
  1104.                 break; 
  1105.               case 2: 
  1106.                 wminfo.next = 5; 
  1107.                 break; 
  1108.               case 3: 
  1109.                 wminfo.next = 6; 
  1110.                 break; 
  1111.               case 4:
  1112.                 wminfo.next = 2;
  1113.                 break;
  1114.             }                
  1115.         } 
  1116.         else 
  1117.             wminfo.next = gamemap;          // go to next level 
  1118.     }
  1119.                  
  1120.     wminfo.maxkills = totalkills; 
  1121.     wminfo.maxitems = totalitems; 
  1122.     wminfo.maxsecret = totalsecret; 
  1123.     wminfo.maxfrags = 0; 
  1124.     if ( gamemode == commercial )
  1125.         wminfo.partime = 35*cpars[gamemap-1]; 
  1126.     else
  1127.         wminfo.partime = 35*pars[gameepisode][gamemap]; 
  1128.     wminfo.pnum = consoleplayer; 
  1129.  
  1130.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1131.     { 
  1132.         wminfo.plyr[i].in = playeringame[i]; 
  1133.         wminfo.plyr[i].skills = players[i].killcount; 
  1134.         wminfo.plyr[i].sitems = players[i].itemcount; 
  1135.         wminfo.plyr[i].ssecret = players[i].secretcount; 
  1136.         wminfo.plyr[i].stime = leveltime; 
  1137.         memcpy (wminfo.plyr[i].frags, players[i].frags 
  1138.                 , sizeof(wminfo.plyr[i].frags)); 
  1139.     } 
  1140.  
  1141.     gamestate = GS_INTERMISSION; 
  1142.     viewactive = false; 
  1143.     automapactive = false; 
  1144.  
  1145.     if (statcopy)
  1146.         memcpy (statcopy, &wminfo, sizeof(wminfo));
  1147.         
  1148.     WI_Start (&wminfo); 
  1149. } 
  1150.  
  1151.  
  1152. //
  1153. // G_WorldDone 
  1154. //
  1155. void G_WorldDone (void) 
  1156. { 
  1157.     gameaction = ga_worlddone; 
  1158.  
  1159.     if (secretexit) 
  1160.         players[consoleplayer].didsecret = true; 
  1161.  
  1162.     if ( gamemode == commercial )
  1163.     {
  1164.         switch (gamemap)
  1165.         {
  1166.           case 15:
  1167.           case 31:
  1168.             if (!secretexit)
  1169.                 break;
  1170.           case 6:
  1171.           case 11:
  1172.           case 20:
  1173.           case 30:
  1174.             F_StartFinale ();
  1175.             break;
  1176.         }
  1177.     }
  1178. } 
  1179.  
  1180. void G_DoWorldDone (void) 
  1181. {        
  1182.     gamestate = GS_LEVEL; 
  1183.     gamemap = wminfo.next+1; 
  1184.     G_DoLoadLevel (); 
  1185.     gameaction = ga_nothing; 
  1186.     viewactive = true; 
  1187. } 
  1188.  
  1189.  
  1190.  
  1191. //
  1192. // G_InitFromSavegame
  1193. // Can be called by the startup code or the menu task. 
  1194. //
  1195. extern boolean setsizeneeded;
  1196. void R_ExecuteSetViewSize (void);
  1197.  
  1198. char    savename[256];
  1199.  
  1200. void G_LoadGame (char* name) 
  1201. { 
  1202.     strcpy (savename, name); 
  1203.     gameaction = ga_loadgame; 
  1204. } 
  1205.  
  1206. #define VERSIONSIZE             16 
  1207.  
  1208.  
  1209. void G_DoLoadGame (void) 
  1210. { 
  1211.     int         length; 
  1212.     int         i; 
  1213.     int         a,b,c; 
  1214.     char        vcheck[VERSIONSIZE]; 
  1215.          
  1216.     gameaction = ga_nothing; 
  1217.          
  1218.     length = M_ReadFile (savename, &savebuffer); 
  1219.     save_p = savebuffer + SAVESTRINGSIZE;
  1220.     
  1221.     // skip the description field 
  1222.     memset (vcheck,0,sizeof(vcheck)); 
  1223.     sprintf (vcheck,"version %i",VERSION); 
  1224.     if (strcmp (save_p, vcheck)) 
  1225.         return;                         // bad version 
  1226.     save_p += VERSIONSIZE; 
  1227.                          
  1228.     gameskill = *save_p++; 
  1229.     gameepisode = *save_p++; 
  1230.     gamemap = *save_p++; 
  1231.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1232.         playeringame[i] = *save_p++; 
  1233.  
  1234.     // load a base level 
  1235.     G_InitNew (gameskill, gameepisode, gamemap); 
  1236.  
  1237.     // get the times 
  1238.     a = *save_p++; 
  1239.     b = *save_p++; 
  1240.     c = *save_p++; 
  1241.     leveltime = (a<<16) + (b<<8) + c; 
  1242.          
  1243.     // dearchive all the modifications
  1244.     P_UnArchivePlayers (); 
  1245.     P_UnArchiveWorld (); 
  1246.     P_UnArchiveThinkers (); 
  1247.     P_UnArchiveSpecials (); 
  1248.  
  1249.     if (*save_p != 0x1d) 
  1250.         I_Error ("Bad savegame");
  1251.     
  1252.     // done 
  1253.     Z_Free (savebuffer); 
  1254.  
  1255.     if (setsizeneeded)
  1256.         R_ExecuteSetViewSize ();
  1257.     
  1258.     // draw the pattern into the back screen
  1259.     R_FillBackScreen ();   
  1260. } 
  1261.  
  1262.  
  1263. //
  1264. // G_SaveGame
  1265. // Called by the menu task.
  1266. // Description is a 24 byte text string 
  1267. //
  1268. void
  1269. G_SaveGame
  1270. ( int   slot,
  1271.   char* description ) 
  1272. { 
  1273.     savegameslot = slot; 
  1274.     strcpy (savedescription, description); 
  1275.     sendsave = true; 
  1276. } 
  1277.  
  1278. void G_DoSaveGame (void) 
  1279. { 
  1280.     char        name[100]; 
  1281.     char        name2[VERSIONSIZE]; 
  1282.     char*       description; 
  1283.     int         length; 
  1284.     int         i; 
  1285.         
  1286.     if (M_CheckParm("-cdrom"))
  1287.         sprintf(name,"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",savegameslot);
  1288.     else
  1289.         sprintf (name,SAVEGAMENAME"%d.dsg",savegameslot); 
  1290.     description = savedescription; 
  1291.          
  1292.     save_p = savebuffer = screens[1]+0x4000; 
  1293.          
  1294.     memcpy (save_p, description, SAVESTRINGSIZE); 
  1295.     save_p += SAVESTRINGSIZE; 
  1296.     memset (name2,0,sizeof(name2)); 
  1297.     sprintf (name2,"version %i",VERSION); 
  1298.     memcpy (save_p, name2, VERSIONSIZE); 
  1299.     save_p += VERSIONSIZE; 
  1300.          
  1301.     *save_p++ = gameskill; 
  1302.     *save_p++ = gameepisode; 
  1303.     *save_p++ = gamemap; 
  1304.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1305.         *save_p++ = playeringame[i]; 
  1306.     *save_p++ = leveltime>>16; 
  1307.     *save_p++ = leveltime>>8; 
  1308.     *save_p++ = leveltime; 
  1309.  
  1310.     P_ArchivePlayers (); 
  1311.     P_ArchiveWorld (); 
  1312.     P_ArchiveThinkers (); 
  1313.     P_ArchiveSpecials (); 
  1314.          
  1315.     *save_p++ = 0x1d;           // consistancy marker 
  1316.          
  1317.     length = save_p - savebuffer; 
  1318.     if (length > SAVEGAMESIZE) 
  1319.         I_Error ("Savegame buffer overrun"); 
  1320.     M_WriteFile (name, savebuffer, length); 
  1321.     gameaction = ga_nothing; 
  1322.     savedescription[0] = 0;              
  1323.          
  1324.     players[consoleplayer].message = GGSAVED; 
  1325.  
  1326.     // draw the pattern into the back screen
  1327.     R_FillBackScreen ();        
  1328. } 
  1329.  
  1330.  
  1331. //
  1332. // G_InitNew
  1333. // Can be called by the startup code or the menu task,
  1334. // consoleplayer, displayplayer, playeringame[] should be set. 
  1335. //
  1336. skill_t d_skill; 
  1337. int     d_episode; 
  1338. int     d_map; 
  1339.  
  1340. void
  1341. G_DeferedInitNew
  1342. ( skill_t       skill,
  1343.   int           episode,
  1344.   int           map) 
  1345. { 
  1346.     d_skill = skill; 
  1347.     d_episode = episode; 
  1348.     d_map = map; 
  1349.     gameaction = ga_newgame; 
  1350. } 
  1351.  
  1352.  
  1353. void G_DoNewGame (void) 
  1354. {
  1355.     demoplayback = false; 
  1356.     netdemo = false;
  1357.     netgame = false;
  1358.     deathmatch = false;
  1359.     playeringame[1] = playeringame[2] = playeringame[3] = 0;
  1360.     respawnparm = false;
  1361.     fastparm = false;
  1362.     nomonsters = false;
  1363.     consoleplayer = 0;
  1364.     G_InitNew (d_skill, d_episode, d_map); 
  1365.     gameaction = ga_nothing; 
  1366. } 
  1367.  
  1368. // The sky texture to be used instead of the F_SKY1 dummy.
  1369. extern  int     skytexture; 
  1370.  
  1371.  
  1372. void
  1373. G_InitNew
  1374. ( skill_t       skill,
  1375.   int           episode,
  1376.   int           map ) 
  1377. { 
  1378.     int             i; 
  1379.          
  1380.     if (paused) 
  1381.     { 
  1382.         paused = false; 
  1383.         S_ResumeSound (); 
  1384.     } 
  1385.         
  1386.  
  1387.     if (skill > sk_nightmare) 
  1388.         skill = sk_nightmare;
  1389.  
  1390.  
  1391.     // This was quite messy with SPECIAL and commented parts.
  1392.     // Supposedly hacks to make the latest edition work.
  1393.     // It might not work properly.
  1394.     if (episode < 1)
  1395.       episode = 1; 
  1396.  
  1397.     if ( gamemode == retail )
  1398.     {
  1399.       if (episode > 4)
  1400.         episode = 4;
  1401.     }
  1402.     else if ( gamemode == shareware )
  1403.     {
  1404.       if (episode > 1) 
  1405.            episode = 1; // only start episode 1 on shareware
  1406.     }  
  1407.     else
  1408.     {
  1409.       if (episode > 3)
  1410.         episode = 3;
  1411.     }
  1412.     
  1413.  
  1414.   
  1415.     if (map < 1) 
  1416.         map = 1;
  1417.     
  1418.     if ( (map > 9)
  1419.          && ( gamemode != commercial) )
  1420.       map = 9; 
  1421.                  
  1422.     M_ClearRandom (); 
  1423.          
  1424.     if (skill == sk_nightmare || respawnparm )
  1425.         respawnmonsters = true;
  1426.     else
  1427.         respawnmonsters = false;
  1428.                 
  1429.     if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
  1430.     { 
  1431.         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1432.             states[i].tics >>= 1; 
  1433.         mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT; 
  1434.         mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT; 
  1435.         mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT; 
  1436.     } 
  1437.     else if (skill != sk_nightmare && gameskill == sk_nightmare) 
  1438.     { 
  1439.         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1440.             states[i].tics <<= 1; 
  1441.         mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT; 
  1442.         mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT; 
  1443.         mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT; 
  1444.     } 
  1445.          
  1446.                          
  1447.     // force players to be initialized upon first level load         
  1448.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1449.         players[i].playerstate = PST_REBORN; 
  1450.  
  1451.     usergame = true;                // will be set false if a demo 
  1452.     paused = false; 
  1453.     demoplayback = false; 
  1454.     automapactive = false; 
  1455.     viewactive = true; 
  1456.     gameepisode = episode; 
  1457.     gamemap = map; 
  1458.     gameskill = skill; 
  1459.  
  1460.     viewactive = true;
  1461.     
  1462.     // set the sky map for the episode
  1463.     if ( gamemode == commercial)
  1464.     {
  1465.         skytexture = R_TextureNumForName ("SKY3");
  1466.         if (gamemap < 12)
  1467.             skytexture = R_TextureNumForName ("SKY1");
  1468.         else
  1469.             if (gamemap < 21)
  1470.                 skytexture = R_TextureNumForName ("SKY2");
  1471.     }
  1472.     else
  1473.         switch (episode) 
  1474.         { 
  1475.           case 1: 
  1476.             skytexture = R_TextureNumForName ("SKY1"); 
  1477.             break; 
  1478.           case 2: 
  1479.             skytexture = R_TextureNumForName ("SKY2"); 
  1480.             break; 
  1481.           case 3: 
  1482.             skytexture = R_TextureNumForName ("SKY3"); 
  1483.             break; 
  1484.           case 4:       // Special Edition sky
  1485.             skytexture = R_TextureNumForName ("SKY4");
  1486.             break;
  1487.         } 
  1488.  
  1489.     G_DoLoadLevel (); 
  1490. } 
  1491.  
  1492.  
  1493. //
  1494. // DEMO RECORDING 
  1495. // 
  1496. #define DEMOMARKER              0x80
  1497.  
  1498.  
  1499. void G_ReadDemoTiccmd (ticcmd_t* cmd) 
  1500. { 
  1501.     if (*demo_p == DEMOMARKER) 
  1502.     {
  1503.         // end of demo data stream 
  1504.         G_CheckDemoStatus (); 
  1505.         return; 
  1506.     } 
  1507.     cmd->forwardmove = ((signed char)*demo_p++); 
  1508.     cmd->sidemove = ((signed char)*demo_p++); 
  1509.     cmd->angleturn = ((unsigned char)*demo_p++)<<8; 
  1510.     cmd->buttons = (unsigned char)*demo_p++; 
  1511. } 
  1512.  
  1513.  
  1514. void G_WriteDemoTiccmd (ticcmd_t* cmd) 
  1515. { 
  1516.     if (gamekeydown['q'])           // press q to end demo recording 
  1517.         G_CheckDemoStatus (); 
  1518.     *demo_p++ = cmd->forwardmove; 
  1519.     *demo_p++ = cmd->sidemove; 
  1520.     *demo_p++ = (cmd->angleturn+128)>>8; 
  1521.     *demo_p++ = cmd->buttons; 
  1522.     demo_p -= 4; 
  1523.     if (demo_p > demoend - 16)
  1524.     {
  1525.         // no more space 
  1526.         G_CheckDemoStatus (); 
  1527.         return; 
  1528.     } 
  1529.         
  1530.     G_ReadDemoTiccmd (cmd);         // make SURE it is exactly the same 
  1531. } 
  1532.  
  1533.  
  1534.  
  1535. //
  1536. // G_RecordDemo 
  1537. // 
  1538. void G_RecordDemo (char* name) 
  1539. { 
  1540.     int             i; 
  1541.     int                         maxsize;
  1542.         
  1543.     usergame = false; 
  1544.     strcpy (demoname, name); 
  1545.     strcat (demoname, ".lmp"); 
  1546.     maxsize = 0x20000;
  1547.     i = M_CheckParm ("-maxdemo");
  1548.     if (i && i<myargc-1)
  1549.         maxsize = atoi(myargv[i+1])*1024;
  1550.     demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL); 
  1551.     demoend = demobuffer + maxsize;
  1552.         
  1553.     demorecording = true; 
  1554. } 
  1555.  
  1556.  
  1557. void G_BeginRecording (void) 
  1558. { 
  1559.     int             i; 
  1560.                 
  1561.     demo_p = demobuffer;
  1562.         
  1563.     *demo_p++ = VERSION;
  1564.     *demo_p++ = gameskill; 
  1565.     *demo_p++ = gameepisode; 
  1566.     *demo_p++ = gamemap; 
  1567.     *demo_p++ = deathmatch; 
  1568.     *demo_p++ = respawnparm;
  1569.     *demo_p++ = fastparm;
  1570.     *demo_p++ = nomonsters;
  1571.     *demo_p++ = consoleplayer;
  1572.          
  1573.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1574.         *demo_p++ = playeringame[i];             
  1575. } 
  1576.  
  1577.  
  1578. //
  1579. // G_PlayDemo 
  1580. //
  1581.  
  1582. char*   defdemoname; 
  1583.  
  1584. void G_DeferedPlayDemo (char* name) 
  1585. { 
  1586.     defdemoname = name; 
  1587.     gameaction = ga_playdemo; 
  1588. } 
  1589.  
  1590. void G_DoPlayDemo (void) 
  1591. { 
  1592.     skill_t skill; 
  1593.     int             i, episode, map; 
  1594.          
  1595.     gameaction = ga_nothing; 
  1596.     demobuffer = demo_p = W_CacheLumpName (defdemoname, PU_STATIC); 
  1597.     if ( *demo_p++ != VERSION && !M_CheckParm("-forcedemo"))
  1598.     {
  1599.       fprintf( stderr, "Demo is from a different game version!\n");
  1600.             fflush(stderr);
  1601.       gameaction = ga_nothing;
  1602.       return;
  1603.     }
  1604.     
  1605.     skill = *demo_p++; 
  1606.     episode = *demo_p++; 
  1607.     map = *demo_p++; 
  1608.     deathmatch = *demo_p++;
  1609.     respawnparm = *demo_p++;
  1610.     fastparm = *demo_p++;
  1611.     nomonsters = *demo_p++;
  1612.     consoleplayer = *demo_p++;
  1613.         
  1614.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1615.         playeringame[i] = *demo_p++; 
  1616.     if (playeringame[1]) 
  1617.     { 
  1618.         netgame = true; 
  1619.         netdemo = true; 
  1620.     }
  1621.  
  1622.     // don't spend a lot of time in loadlevel 
  1623.     precache = false;
  1624.     G_InitNew (skill, episode, map); 
  1625.     precache = true; 
  1626.  
  1627.     usergame = false; 
  1628.     demoplayback = true; 
  1629. } 
  1630.  
  1631. //
  1632. // G_TimeDemo 
  1633. //
  1634. void G_TimeDemo (char* name) 
  1635. {        
  1636.     nodrawers = M_CheckParm ("-nodraw"); 
  1637.     noblit = M_CheckParm ("-noblit"); 
  1638.     timingdemo = true; 
  1639.     singletics = true; 
  1640.  
  1641.     defdemoname = name; 
  1642.     gameaction = ga_playdemo; 
  1643. } 
  1644.  
  1645.  
  1646. /* 
  1647. =================== 
  1648. = 
  1649. = G_CheckDemoStatus 
  1650. = 
  1651. = Called after a death or level completion to allow demos to be cleaned up 
  1652. = Returns true if a new demo loop action will take place 
  1653. =================== 
  1654. */ 
  1655.  
  1656. boolean G_CheckDemoStatus (void) 
  1657. { 
  1658.     int             endtime; 
  1659.          
  1660.     if (timingdemo) 
  1661.     { 
  1662.         endtime = I_GetTime ();
  1663.         I_Error ("timed %i gametics in %i realtics (%5.2f fps)",gametic 
  1664.                  , endtime-starttime, ((float)gametic/(float)endtime-(float)starttime)*35); 
  1665.     } 
  1666.          
  1667.     if (demoplayback) 
  1668.     { 
  1669.         if (singledemo) 
  1670.             I_Quit (); 
  1671.                          
  1672.         Z_ChangeTag (demobuffer, PU_CACHE); 
  1673.         demoplayback = false; 
  1674.         netdemo = false;
  1675.         netgame = false;
  1676.         deathmatch = false;
  1677.         playeringame[1] = playeringame[2] = playeringame[3] = 0;
  1678.         respawnparm = false;
  1679.         fastparm = false;
  1680.         nomonsters = false;
  1681.         consoleplayer = 0;
  1682.         D_AdvanceDemo (); 
  1683.         return true; 
  1684.     } 
  1685.  
  1686.     if (demorecording) 
  1687.     { 
  1688.         *demo_p++ = DEMOMARKER; 
  1689.         M_WriteFile (demoname, demobuffer, demo_p - demobuffer); 
  1690.         Z_Free (demobuffer); 
  1691.         demorecording = false; 
  1692.         I_Error ("Demo %s recorded",demoname); 
  1693.     } 
  1694.          
  1695.     return false; 
  1696. } 
  1697.  
  1698.  
  1699.  
  1700.